package com.indusfo.spc.service.impl;


import com.indusfo.spc.common.utlis.IOUtils;
import com.indusfo.spc.exception.GlobalException;
import com.indusfo.spc.exception.ModifyFailedException;
import com.indusfo.spc.exception.ParamsErrorException;
import com.indusfo.spc.exception.UploadErrorException;
import com.indusfo.spc.mapper.*;
import com.indusfo.spc.pojo.*;
import com.indusfo.spc.service.BasisListService;
import com.indusfo.spc.untlis.GsonUtil;
import com.indusfo.spc.vo.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @ProjectName: IEIS2-COM
 * @Package: com.indusfo.spc.service.impl
 * @ClassName: BasisListServiceImpl
 * @Author: 熊冰
 * @Description: 工艺文件库 业务层
 * @Date: 2019/8/26 14:51
 * @Version: 1.0
 */

@Service
public class BasisListServiceImpl implements BasisListService {

	//日志记录
	private static final Logger logger = LoggerFactory.getLogger(BasisListServiceImpl.class);
	//本地路径
	private String localPath = IOUtils.getClassPath(this).replaceAll("ROOT/WEB-INF/classes/", "");
	@Autowired
	private BasisListMapper basisListMapper;
	@Autowired
	private BasisMapper basisMapper;

	//	@Autowired
//	private ProcessFlowMapper processFlowMapper;
	@Autowired
	private MaterialXOMapper materialXOMapper;
	@Autowired
	private ProcessVerMapper processVerMapper;

	@Autowired
	private ProMapper proMapper;

	//    查询
	@Override
	public JSONObject listBasisList(BasisList basisList) {
		try {
			// 获取一页显示多少行
			Integer pagesize = basisList.getPagesize();
			// 获取查询第几页
			Integer pageindex = basisList.getPageindex();
			//初始值
			// 若不为空计算从第几条开始查询
			if (pagesize != null && pageindex != null) {
				basisList.setIncept(pagesize * (pageindex - 1));
			}
			// 为空进行多条的分页查询
			// 调用Mapper分页查询方法
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
			List<BasisList> listForPage = basisListMapper.selectAllBasisList(basisList);
			for (int i = 0; i < listForPage.size(); i++
			) {
				;
				listForPage.get(i).setVcUpdateTime(df.format(listForPage.get(i).getUpdateTime()));
//                listForPage.set(i,  listForPage.get(i).setVcUpdateTime(df.format( listForPage.get(i).getUpdateTime()))) ;
			}
			// 判断是否查询到数据
			if (listForPage.isEmpty()) {
				return JSONObject.oK("没有查询到数据", listForPage, 0);
			}
			// 查询有多少条数据条数
			if (pagesize != null && pageindex != null) {
				Integer count = basisListMapper.countBasisList(basisList);
				return JSONObject.oK(listForPage, count);
			}
			return JSONObject.oK(listForPage.get(0));


		} catch (GlobalException e) {
			// 捕获异常,打印并返回数
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		}
	}

	//新增
	@Override
	public synchronized JSONObject insertOrUpdateBasisList(BasisList basisList) {
		try {

			//更新Basis
			if (basisList == null) {
				throw new ModifyFailedException("数据不能为空！");
			}
			if (basisList.getMatId() == null) {
				throw new ModifyFailedException("没有产品编号！");
			}
			//更新BasisList
			if (basisList.getProId() == null) {
				basisList.setProId(0);
			}
			if (basisList.getDataState() == null) {
				basisList.setDataState(1);
			}

			JSONObject checkParamsNotRepeatJson = checkParamsNotRepeat(basisList);
			validate(basisList);
			if (checkParamsNotRepeatJson.isOk()) {

				if (basisList.getBasislistId() != null) {// 有id,做更新

					Integer row = basisListMapper.updateByPrimaryKeySelective(basisList);
					if (row == 0) {
						throw new ModifyFailedException("更新工艺文件库失败！");
					}

					// 根据返回的影响行数判断是否成功
					//新增或修改basis
					Basis basis = new Basis();
					basis.setlProduct(basisList.getMatId());
					basis.setdLastUploadTime(basisList.getUpdateTime());
					basis.setlDataState(1);
					basis.setlUserId(1);
					List<Basis> basisDOS = basisMapper.queryBasisByMatId(basis);

					if (basisDOS.size() == 0) {
						//新增
						basisMapper.insertSelective(basis);
						System.out.println("新增成功");
					} else {
						basis = basisDOS.get(0);
						//修改\
						basisMapper.updateBasisByBasisIdForNullTime(basis);
						System.out.println("修改成功");
					}
					return JSONObject.oK("更新成功！", row);
				} else {// 没id,做新增
					// 校验传入参数
					Integer row = basisListMapper.insertSelective(basisList);
					if (row == 0) {
						throw new ModifyFailedException("新增工艺文件库失败！");
					}
					//新增或修改basis
					Basis basis = new Basis();
					basis.setlProduct(basisList.getMatId());
					basis.setdLastUploadTime(basisList.getUpdateTime());
					basis.setlDataState(1);
					basis.setlUserId(1);
					List<Basis> basisDOS = basisMapper.queryBasisByMatId(basis);

					if (basisDOS.size() == 0) {
						//新增
						basisMapper.insertSelective(basis);
//						System.out.println("新增成功");
					} else {
						basis = basisDOS.get(0);
						//修改\
						basisMapper.updateBasisByBasisIdForNullTime(basis);
//						System.out.println("修改成功");
					}
					return JSONObject.oK("新增成功！", row);
				}
			} else {
				throw new ParamsErrorException(checkParamsNotRepeatJson.getMsg());
			}


		} catch (GlobalException e) {
			logger.error(e.getMessage());
			return JSONObject.build(500, e.getMessage());
		}
	}

	//删除
	@Override
	public JSONObject deleteBasisList(Long[] deteBasisList, Integer lDataState) {
		try {
			//1.校验
			if (deteBasisList == null) {
				throw new ParamsErrorException("工艺文件库d不能为空");
			}
			if (lDataState == null) {
				throw new ParamsErrorException("工艺文件库状态不能为空");
			}
			int row = basisListMapper.deleteBasisList(deteBasisList, lDataState);
			String msg = "";
			switch (lDataState) {
				case 1:
					msg = "启用";
					break;
				case 2:
					msg = "删除";
					break;
				case 3:
					msg = "停用";
			}

			if (row == 0) {
				// 判断传入的数据状态参数lDataState,返回相应信息
				switch (lDataState) {
					case 1:
						throw new ModifyFailedException(msg + "失败!");
					case 2:
						throw new ModifyFailedException(msg + "失败!");
					case 3:
						throw new ModifyFailedException(msg + "失败!");
				}
			}
			return JSONObject.oK(msg + "成功！", row);
		} catch (GlobalException e) {
			logger.error(e.getMessage());
			return JSONObject.build(500, e.getMessage());
		}
	}

	@Override
	public JSONObject insertFile(MultipartFile uploadFile) {


		try {
			// 获取当前时间
			Date date = new Date();
			// 获取文件名
			String fileName = "EDSF";
			fileName = fileName + uploadFile.getOriginalFilename();
			// 转换为统一的小写形式
			fileName = fileName.toLowerCase();
			// 判断是否为word文档,excel文档,pdf文件的类型
			if (!fileName.matches("^.*(doc|docx|xls|xlsx|xl|xla|xlt|xlm|xlc|xlw|pdf|png|jpg|jpeg)$")) {
				// 说明:如果传递的文件不是指定的格式,直接程序结束
				throw new UploadErrorException("上传的文件格式不符合要求");
			}
			// 将文件分年月存储 yyyy/MM
			String datePath = new SimpleDateFormat("yyyy/MM").format(date);
			// 存放的目标目录
			String target = "../../../upload/";
			// 判断是否有该文件夹:项目目录+upload/2018/10
			String fileDir = localPath + target + datePath;
			File fileFile = new File(fileDir);

			if (!fileFile.exists()) {
				// 没有则创建目录
				fileFile.mkdirs();
			}

			// 生成文件上传时间的字符串,用于文件重命名,格式为:yyyy-MM-dd-HH-mm-ss-SSS;2018-01-01-07-05-09-000;年-月-日-时-分-秒-毫秒
			String dateString = new SimpleDateFormat("dd").format(date);
			// 生成随机码,双重保险防止文件重名
			int randomNum = new Random().nextInt(1000);
			// 获取图片的后缀名.doc
			String fileType = fileName.substring(fileName.lastIndexOf("."));

			// 拼接文件的名称
			String fileNowName = dateString + "" + randomNum + fileType;
			// 实现文件保存:当前项目路径/yyyy/MM/1231231231231231231.jpg
			String realFilePath = fileDir + "/" + fileNowName;
			uploadFile.transferTo(new File(realFilePath));

			/**
			 * 对图片的项目路径进行拼接
			 * 项目路径/2018/10/2018-01-01-07-05-09-000-randomNum564.doc
			 */
			String realUrl = target.substring(9) + datePath + "/" + fileNowName;


			// 开启一个线程，去执行word转pdf转png动作
			logger.info("开启一个线程，去执行word转pdf转png动作");
			OfficeTransformThread officeT = new OfficeTransformThread(realFilePath);
			new Thread(officeT).start();
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
			Map<String, Object> map = new HashMap<>();


			map.put("content", realUrl);
			map.put("updateTime", df.format(date));
			// 将路径返回
			return JSONObject.build(200, "保存成功!", map);
		} catch (GlobalException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (IllegalStateException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (IOException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (Exception e) {
			logger.error("未知错误！", e);
			return JSONObject.build(500, e.getMessage());
		}
	}

	//批量新增
	@Override
	public JSONObject batchInsertBasisList(List<BasisList> basisLists) {
		try {
			if (basisLists == null) {
				throw new ModifyFailedException("数据不能为空！");
			}

			Integer row = 0;
			if (basisLists.get(0).getMatId() == null) {
				throw new ModifyFailedException("没有产品编号！");
			} else {
				Basis basis = new Basis();
				basis.setlProduct(basisLists.get(0).getMatId());
				basis.setlUserId(1);
				basis.setlDataState(1);
				basis.setdLastUploadTime(basisLists.get(0).getUpdateTime());
				int rows = basisMapper.countParamsNotRepeat(basis);
				if (rows == 0) {
					//新增
					row = row + basisMapper.insertSelective(basis);
				} else {
					List<Basis> basisDOS = basisMapper.queryBasisByMatId(basis);
					if (basisDOS.size() != 0) {
						basis = basisDOS.get(0);
						//修改
						row = row + basisMapper.updateBasisByBasisIdForNullTime(basis);
					} else {
						throw new ModifyFailedException("没有产品！");
					}

				}

			}
			for (BasisList basisList : basisLists) {
				validate(basisList);
				JSONObject checkParamsNotRepeatJson = checkParamsNotRepeat(basisList);
				if (basisList.getBasislistId() == null) {
					//新增
					row = row + basisListMapper.insertSelective(basisList);
				} else {
					//修改
					row = row + basisListMapper.updateByPrimaryKeySelective(basisList);
				}

			}
			if (row == 0) {
				throw new ModifyFailedException("新增工艺文件库失败！");
			}
			return JSONObject.oK("新增成功！", row);
		} catch (GlobalException e) {
			logger.error(e.getMessage());
			return JSONObject.build(500, e.getMessage());
		}

	}

	@Override
	public JSONObject leadFile(MultipartFile file) {

		try {
			// 获取当前时间
			Date date = new Date();
			// 获取文件名
			String fileName = "EDSF_";
			fileName = fileName + file.getOriginalFilename();
			//获取数据
			List<BasisList> basisListpro = new ArrayList<>();


			String[] split = fileName.split("_");
			if (split.length != 4) {
				// 说明:如果传递的文件不是指定的格式,直接程序结束
				throw new UploadErrorException("上传的文件名称不符合要求 产品编号_工艺版本名称_工序名称.文件后缀");
			}
			String str = split[3];
			split[3] = str.substring(0, str.indexOf("."));

			//查看是否有多个值
			String[] matcode = split[1].split(",");
			String[] vcver = split[2].split(",");
			String[] vcpro = split[3].split(",");
			for (int i = 0; i < matcode.length; i++) {
				for (int j = 0; j < matcode.length; j++) {
					for (int k = 0; k < matcode.length; k++) {
						BasisList basisList1 = new BasisList();
						if ("all".equals(matcode[i])) {
							basisList1.setVcMatCode(null);
						} else {
							basisList1.setVcMatCode(matcode[i]);
						}
						if ("all".equals(vcver[j])) {
							basisList1.setVcVersion(null);
						} else {
							basisList1.setVcVersion(vcver[j]);
						}
						if ("all".equals(vcpro[k])) {
							basisList1.setVcProName(null);
						} else {
							basisList1.setVcProName(vcpro[k]);
						}
						basisListpro.add(basisList1);
					}
				}
			}
			//剔除重复数据
			basisListpro = getRidOf(basisListpro);
			//查询所有符合要求的数据
			List<BasisList> basisListall = new ArrayList<>();
			for (BasisList b : basisListpro) {
				basisListall.addAll(basisListMapper.queryAllPro(b));
			}
			//剔除重复数据
			basisListall = getRidOf(basisListall);


//            //获取物料
//            MaterialXO materialXO=new MaterialXO();
//            materialXO.setVcMatCode(split[1]);
//            List<MaterialXO> materialXOS = materialXOMapper.selectAllMaterialXO(materialXO);
//            if (materialXOS.size()==0) {
//                // 说明:如果传递的文件不是指定的格式,直接程序结束
//                throw new UploadErrorException("不存在该物料");
//            }
//            materialXO=materialXOS.get(0);
//            basisList.setMatId(materialXO.getlMatId());
//            //获取版本
//            ProcessVer processVer=new ProcessVer();
//            processVer.setlProduct(materialXO.getlMatId());
//            processVer.setlMatId(materialXO.getlMatId());
//            processVer.setVcVersion(split[2]);
//            List<ProcessVer> processVers = processVerMapper.queryProcessVer(processVer);
//            if (processVers.size()==0) {
//                // 说明:如果传递的文件不是指定的格式,直接程序结束
//                throw new UploadErrorException("不存在该版本");
//            }
//            processVer=processVers.get(0);
//            basisList.setlProVer(processVer.getlProVer());
//            //获取工序
//            Pro pro=new Pro();
//            pro.setVcProName(split[3]);
//            List<Pro> pros = proMapper.listPros(pro);
//            if (pros.size()==0) {
//                // 说明:如果传递的文件不是指定的格式,直接程序结束
//                throw new UploadErrorException("不存在该工序");
//            }
//            pro=pros.get(0);
//
//
//
//
//            basisList.setProId(pro.getlProId());


			//获取修改的id

			//传入默认值、、
			//****************************************
			fileName = fileName.toLowerCase();
			if (!fileName.matches("^.*(doc|docx|xls|xlsx|xl|xla|xlt|xlm|xlc|xlw|pdf|png|jpg|jpeg)$")) {
				throw new UploadErrorException("上传的文件格式不符合要求");
			}
			String datePath = new SimpleDateFormat("yyyy/MM").format(date);
			String target = "../../../upload/";
			String fileDir = localPath + target + datePath;
			File fileFile = new File(fileDir);
			if (!fileFile.exists()) {
				fileFile.mkdirs();
			}

			//*********************************
			String dateString = new SimpleDateFormat("dd").format(date);
			int randomNum = new Random().nextInt(1000);
			String fileType = fileName.substring(fileName.lastIndexOf("."));
			String fileNowName = dateString + "" + randomNum + fileType;
			String realFilePath = fileDir + "/" + fileNowName;
			file.transferTo(new File(realFilePath));
			randomNum = new Random().nextInt(1000);
			String realUrl = target.substring(9) + datePath + "/" + fileNowName;
			//*********************************



//			// 转换为统一的小写形式
//			fileName = fileName.toLowerCase();
//			// 判断是否为word文档,excel文档,pdf文件的类型
//			if (!fileName.matches("^.*(doc|docx|xls|xlsx|xl|xla|xlt|xlm|xlc|xlw|pdf)$")) {
//				// 说明:如果传递的文件不是指定的格式,直接程序结束
//				throw new UploadErrorException("上传的文件格式不符合要求");
//			}
//			// 将文件分年月存储 yyyy/MM
//			String datePath = new SimpleDateFormat("yyyy/MM").format(date);
//			// 存放的目标目录
//			String target = "upload/";
//			// 判断是否有该文件夹:项目目录+upload/2018/10
//			String fileDir = localPath + target + datePath;
//			File fileFile = new File(fileDir);
//
//			if (!fileFile.exists()) {
//				// 没有则创建目录
//				fileFile.mkdirs();
//			}

//			// 生成文件上传时间的字符串,用于文件重命名,格式为:yyyy-MM-dd-HH-mm-ss-SSS;2018-01-01-07-05-09-000;年-月-日-时-分-秒-毫秒
//			String dateString = new SimpleDateFormat("dd").format(date);
//			// 生成随机码,双重保险防止文件重名
//			int randomNum = new Random().nextInt(1000);
//			// 获取图片的后缀名.doc
//			String fileType = fileName.substring(fileName.lastIndexOf("."));
//
//			// 拼接文件的名称
//			String fileNowName = dateString + "" + randomNum + fileType;
//			// 实现文件保存:当前项目路径/yyyy/MM/1231231231231231231.jpg
//			String realFilePath = fileDir + "/" + fileNowName;
//			file.transferTo(new File(realFilePath));
//
//			/**
//			 * 对图片的项目路径进行拼接
//			 * 项目路径/2018/10/2018-01-01-07-05-09-000-randomNum564.doc
//			 */
//			String realUrl = target + datePath + "/" + fileNowName;
//
//
//			// 开启一个线程，去执行word转pdf转png动作
//			logger.info("开启一个线程，去执行word转pdf转png动作");
//			OfficeTransformThread officeT = new OfficeTransformThread(realFilePath);
//			new Thread(officeT).start();
//			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
//			Map<String, Object> map = new HashMap<>();
//			map.put("content", realUrl);
//			map.put("updateTime", df.format(date));
			int insertrow = 0;
			int updaterow = 0;
			int failrow = 0;

//			System.out.println("--------------"+ basisListall.size());
//			System.out.println("--------------"+ basisListall.toString());
			for (int i = 0; i < basisListall.size(); i++) {
				BasisList basisList = new BasisList();
				List<BasisList> basisLists = basisListMapper.selectAllBasisList(basisListall.get(i));

				if (basisLists.size() != 0) {
					basisListall.get(i).setBasislistId(basisLists.get(0).getBasislistId());
				}


				basisList = basisListall.get(i);

//				randomNum = new Random().nextInt(1000);
//				fileNowName = dateString + "" + randomNum + fileType;
//				realFilePath = fileDir + "/" + fileNowName;
//				leadFileTo(file,realFilePath);
//				String realUrl = target + datePath + "/" + fileNowName;

//				// 生成文件上传时间的字符串,用于文件重命名,格式为:yyyy-MM-dd-HH-mm-ss-SSS;2018-01-01-07-05-09-000;年-月-日-时-分-秒-毫秒
//				String dateString = new SimpleDateFormat("dd").format(date);
//				// 生成随机码,双重保险防止文件重名
//				int randomNum = new Random().nextInt(1000);
//				// 获取图片的后缀名.doc
//				String fileType = fileName.substring(fileName.lastIndexOf("."));
//
//				// 拼接文件的名称
//				String fileNowName = dateString + "" + randomNum + fileType;
//				// 实现文件保存:当前项目路径/yyyy/MM/1231231231231231231.jpg
//				String realFilePath = fileDir + "/" + fileNowName;
//				file.transferTo(new File(realFilePath));
//
//				/**
//				 * 对图片的项目路径进行拼接
//				 * 项目路径/2018/10/2018-01-01-07-05-09-000-randomNum564.doc
//				 */
//				String realUrl = target + datePath + "/" + fileNowName;


//				System.out.println("--------------"+ basisList.toString());
//				//通过编号找到对应id
//				MaterialXO materialXO = new MaterialXO();
//				materialXO.setVcMatCode(basisList.getVcMatCode());
//				List<MaterialXO> materialXOS = materialXOMapper.selectAllMaterialXO(materialXO);
//				if (materialXOS.size() == 0) {
//					// 说明:如果传递的文件不是指定的格式,直接程序结束
//					throw new UploadErrorException("不存在该物料");
//				}
//				materialXO = materialXOS.get(0);
//				basisList.setMatId(materialXO.getlMatId());
//
//				//获取版本
//            ProcessVer processVer=new ProcessVer();
//            processVer.setlProduct(materialXO.getlMatId());
//            processVer.setlMatId(materialXO.getlMatId());
//            processVer.setVcVersion(basisList.getVcVersion());
//            List<ProcessVer> processVers = processVerMapper.queryProcessVer(processVer);
//            if (processVers.size()==0) {
//                // 说明:如果传递的文件不是指定的格式,直接程序结束
//                throw new UploadErrorException("不存在该版本");
//            }
//            processVer=processVers.get(0);
//            basisList.setlProVer(processVer.getlProVer());
//            //获取工序
//            Pro pro=new Pro();
//            pro.setVcProName(basisList.getVcProName());
//            List<Pro> pros = proMapper.listPros(pro);
//            if (pros.size()==0) {
//                // 说明:如果传递的文件不是指定的格式,直接程序结束
//                throw new UploadErrorException("不存在该工序");
//            }
//                pro=pros.get(0);
//				basisList.setProId(pro.getlProId());

				basisList.setUpdateTime(new Date());
				basisList.setDataState(1);
				basisList.setContent(realUrl);
//				System.out.println("+++++++++"+basisList);

				JSONObject jsonObject = insertOrUpdateBasisList(basisList);
				if ("新增成功！".equals(jsonObject.getMsg())) {
					insertrow++;
				} else if ("更新成功！".equals(jsonObject.getMsg())) {
					updaterow++;
				} else {
					failrow++;
				}

			}


			// 将路径返回
			return JSONObject.build(200, "新增" + insertrow + "条，修改" + updaterow + "条，失败" + failrow);
		} catch (GlobalException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (IllegalStateException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (Exception e) {
			logger.error("未知错误！", e);
			return JSONObject.build(500, e.getMessage());
		}
	}

	@Override
	public JSONObject batchLeadFile(MultipartFile file,boolean way) {
		try{
			//定义一个message对象用于向前台传输数据
			Message msg = new Message();
			//设置错误集合的
			List<ExcelErrorData> errorDatas = new ArrayList<>();
			Workbook wb = ExcelUtil.getWorkbook(file.getInputStream(), ExcelUtil.isExcel2007(file.getOriginalFilename()));
			if (wb == null) {
				errorDatas.add(ExcelErrorData.getExcelErrorData(0, 0, "文件解析错误"));
			} else {
				//获取excel文件的第一个sheet
				Sheet sheet = wb.getSheetAt(0);
				if (sheet == null) {
					msg.setCode(2);
					msg.setMsg("未找到需要导入的表格");
					errorDatas.add(ExcelErrorData.getExcelErrorData(0, 0, "未找到需要导入的表格"));
				} else {
					int rowCount = sheet.getLastRowNum();
					if (rowCount < 1) {
						msg.setCode(1);
						msg.setMsg("未找到需要导入的数据，请确认表格是否保存！！！");
						errorDatas.add(ExcelErrorData.getExcelErrorData(0, "未找到需要导入的数据，请确认表格是否保存！！！"));
					} else {
						List<BasisList> addBasisLists = new ArrayList<>();
						for (int i = 1; i <= rowCount; i++) {
							boolean needAdd = true;
							//获取到每一行的每一列的数据
							String vcMatCode =com.indusfo.spc.untlis.ExcelUtil.getCellValue(sheet, i, 0, false);
							String vcVersion = com.indusfo.spc.untlis.ExcelUtil.getCellValue(sheet, i, 1, false);
							String vcProName = com.indusfo.spc.untlis.ExcelUtil.getCellValue(sheet, i, 2, false);
							String content = com.indusfo.spc.untlis.ExcelUtil.getCellValue(sheet, i, 3, false);
							BasisList basisList=new BasisList();
							basisList.setVcMatCode(vcMatCode);
							basisList.setVcVersion(vcVersion);
							basisList.setVcProName(vcProName);
							basisList.setContent(content);
							String result =null;
							//            //获取物料
							if (StringUtils.isEmpty(basisList.getContent())) {
								result="文件名称不能为空";
								needAdd=false;
							}

							if (StringUtils.isEmpty(basisList.getVcMatCode())) {
								result="物料编号不能为空";
								needAdd=false;
							}


							if (StringUtils.isEmpty(basisList.getVcVersion())) {
								result = "版本名称不能为空";
								needAdd=false;
							}



							if (StringUtils.isEmpty(basisList.getVcProName())) {
								result = "工序名称不能为空";
								needAdd=false;
							}
							//一段判断
							if(needAdd){

								MaterialXO materialXO=new MaterialXO();
								materialXO.setVcMatCode(vcMatCode);
								List<MaterialXO> materialXOS = materialXOMapper.selectAllMaterialXO(materialXO);
								if (materialXOS.size()==0) {
									// 说明:如果传递的文件不是指定的格式,直接程序结束
									result="不存在该物料";
									needAdd=false;
								}
								//二段判断
								if(needAdd){
									materialXO = materialXOS.get(0);
									basisList.setMatId(materialXO.getlMatId());
									//获取版本
									ProcessVer processVer = new ProcessVer();
									processVer.setlProduct(materialXO.getlMatId());
									processVer.setlMatId(materialXO.getlMatId());
									processVer.setVcVersion(vcVersion);
									List<ProcessVer> processVers = processVerMapper.queryProcessVer(processVer);
									if (processVers.size() == 0) {
										// 说明:如果传递的文件不是指定的格式,直接程序结束
										result = "不存在该版本";
										needAdd=false;
									}
									//三段判断
									if(needAdd){
										processVer = processVers.get(0);
										basisList.setlProVer(processVer.getlProVer());
										//获取工序
										Pro pro = new Pro();
										pro.setVcProName(vcProName);
										List<Pro> pros = proMapper.listPros(pro);
										if (pros.size() == 0) {
											// 说明:如果传递的文件不是指定的格式,直接程序结束
											result = "不存在该工序";
											needAdd=false;
										}
										//四段判断
										if(needAdd){
											pro = pros.get(0);
											basisList.setProId(pro.getlProId());
											basisList.setUpdateTime(new Date());
											basisList.setDataState(1);





											List<BasisList> basisLists = basisListMapper.selectAllBasisList(basisList);

											if (basisLists.size() != 0) {
												basisList.setBasislistId(basisLists.get(0).getBasislistId());
											}



											if (needAdd) {
												addBasisLists.add(basisList);
												insertOrUpdateBasisList(basisList);
											} else {
												msg.setCode(2);
												msg.setMsg("导入数据中存在异常信息");
											}
											//一段判断
										}else{
											msg.setCode(2);
											errorDatas.add(ExcelErrorData.getExcelErrorData(i, result));
										}
										//二段判断
									}else{
										msg.setCode(2);
										errorDatas.add(ExcelErrorData.getExcelErrorData(i, result));
									}
									//三段判断
								}else{
									msg.setCode(2);
									errorDatas.add(ExcelErrorData.getExcelErrorData(i, result));
								}
								//四段判断
							}else{
								msg.setCode(2);
								errorDatas.add(ExcelErrorData.getExcelErrorData(i, result));
							}



						}
						//根据这些来判断是否是中止导入还是跳过继续进行导入
						if (msg.getCode() == 2 && !way) {
							msg.setMsg("中止导入");
						} else {
							if (addBasisLists.size() > 0) {
								try {
//									basisListMapper.updateBasisLists(addBasisLists);
									//当程序执行到这里时,判断信息是否为空为空的话设置导入成功
									msg.setMsg(StringUtils.isBlank(msg.getMsg()) ? "导入成功" : msg.getMsg());
									if ("导入成功".equals(msg.getMsg())) {
										msg.setCode(1);
									}
								} catch (Exception e) {
									e.printStackTrace();
									msg.setMsg("导入失败");
								}
							}else{
								msg.setMsg("导入失败");
							}
						}
						//msg.setData(GsonUtil.toJson(errorDatas));
					}

				}


			}

			msg.setData(GsonUtil.toJson(errorDatas));
			//response.getWriter().println(GsonUtil.toJson(msg));
			String s = GsonUtil.toJson(msg);
			return JSONObject.build(200,msg.getMsg(),errorDatas);
		} catch (GlobalException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (IllegalStateException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		} catch (Exception e) {
			logger.error("未知错误！", e);
			return JSONObject.build(500, e.getMessage());
		}

	}


	//验证重复
	private JSONObject checkParamsNotRepeat(BasisList basisList) {
		try {
			// 判断不良原因类型ID是否传入


			BasisList check = new BasisList();
			check.setContent(basisList.getContent());
			check.setProId(basisList.getProId());
			check.setMatId(basisList.getMatId());
			check.setlProVer(basisList.getlProVer());
			if (basisList.getBasislistId() != null) {
				// 有SOP基础资料ID为更新操作,调用剔除本条记录是否有重复
				check.setBasislistId(basisList.getBasislistId());
//				int row = basisListMapper.countParamsNotRepeat(check);
//				System.out.println(row);
//				row = row + basisListMapper.countCheckNotRepeat(check);
//				System.out.println(row);
				int row = basisListMapper.countCheckNotRepeat(check);
				if (row > 0) {
					throw new ParamsErrorException("已存在该产品!");
				}
			} else {

//				int row = basisListMapper.countParamsNotRepeat(check);
////				System.out.println(row);
//				row = row + basisListMapper.countCheckNotRepeat(check);
//				System.out.println(row);
				int row = basisListMapper.countCheckNotRepeat(check);
				if (row > 0) {
					throw new ParamsErrorException("已存在该产品!");
				}
			}
			return JSONObject.oK();

		} catch (GlobalException e) {
			// 捕获异常,打印并返回
			logger.error(e.getMessage(), e);
			return JSONObject.build(500, e.getMessage());
		}
	}


	//非空判断
	private void validate(BasisList basisList) {
		//类型名称
		String basisListName = basisList.getContent();

		if (StringUtils.isEmpty(basisListName)) {
			throw new ParamsErrorException("文件名称不能为空");
		}
		//物料ID
		Integer matId = basisList.getMatId();
		//工序ID
		Integer proId = basisList.getProId();

		if (matId == null) {
			throw new ParamsErrorException("物料ID不能为空");
		}
		if (proId == null) {
			throw new ParamsErrorException("工序ID不能为空");
		}


	}

	//剔除
	public List<BasisList> getRidOf(List<BasisList> list) {
		List<BasisList> basisLists = new ArrayList<>();

		for (int i = 0; i < list.size(); i++) {
			if (!basisLists.contains(list.get(i))) {
				basisLists.add(list.get(i));
			}
		}
		return basisLists;
	}




//	public JSONObject leadFileTo(MultipartFile file,String filename) {
//
//
//		try {
//			System.out.println("++++++++++++++"+filename);
//			file.transferTo(new File(filename));
//			return JSONObject.build(200, "保存成功!");
//		} catch (GlobalException e) {
//			// 捕获异常,打印并返回
//			logger.error(e.getMessage(), e);
//			return JSONObject.build(500, e.getMessage());
//		} catch (IllegalStateException e) {
//			// 捕获异常,打印并返回
//			logger.error(e.getMessage(), e);
//			return JSONObject.build(500, e.getMessage());
//		} catch (IOException e) {
//			// 捕获异常,打印并返回
//			logger.error(e.getMessage(), e);
//			return JSONObject.build(500, e.getMessage());
//		} catch (Exception e) {
//			logger.error("未知错误！", e);
//			return JSONObject.build(500, e.getMessage());
//		}
//	}

}
